home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Source Code / Ken Long / NewStringArt-c / Original / stringart.c < prev   
Encoding:
C/C++ Source or Header  |  1994-12-04  |  11.5 KB  |  358 lines  |  [TEXT/MACA]
  1. /*
  2.  *    StringArt    May 1985    Ron Hitchens
  3.  *
  4.  *    hitchens@ut-sally.ARPA    ihnp4!ut-sally!hitchens.UUCP
  5.  *
  6.  *    This program was adapted from a demo for the Sun Microsystems
  7.  *    Unix workstation
  8.  *    Ported to the Mac May 10, 1985 by Ron Hitchens
  9.  *
  10.  *    It runs a lot faster on the Sun, even though it's also 68000 based
  11.  *    and is running multituser Unix 4.2BSD, has more layers of software
  12.  *    between you and the screen, and is computing coordinates using
  13.  *    floating point.  It's clock rate is faster, and it's vector drawing
  14.  *    routines are coded for 1-bit-wide lines, but even so...
  15.  *
  16.  *    This program is public domain.  It may be be freely distributed,
  17.  *    copied and used.  All I ask is that my name and this notice remain
  18.  *    on it.  And that modifications be noted in this source listing and
  19.  *    returned to me if possible at the above email address.
  20.  *
  21.  *    History:
  22.  *        May 85    Hitchens    Created.
  23.  *        May 28    Hitchens    Look at screen size vars, add comments
  24.  *
  25.  *
  26.  *    Compilation instructions with Megamax C:
  27.  *    You need the C source files stringart.c and gennums.c
  28.  *        1. compile and link gennums.c
  29.  *        2. run gennums, it creates a C source file named stringnums.c
  30.  *           This name is hard-coded in gennums.c
  31.  *        3. Compile stringnums.c, but don't link it.  Keep stringnums.o
  32.  *        4. Compile stringart.c
  33.  *        5. Link stringart.o and stringnums.o together to make stringart
  34.  *        6. Run StringArt.
  35.  *        7. Sit back and enjoy the show.
  36.  *    If you make changes to stringart, after doing the above, you can skip
  37.  *    to 4.  Stringnums doesn't need to be re-compiled.
  38.  *    If you want to port this to another flavor of C you're on your own.
  39.  *
  40.  *    The icon was created manually with the resource editor, to retain
  41.  *    the icon when recompiling just specify the name of the old 
  42.  *    StringArt application file as the output of the linker.  It will
  43.  *    overwrite the code but won't disturb the icon resources.
  44.  */
  45.  
  46. /*
  47.     This demo creates random vector designs.  This is accomplished by
  48.     randomly choosing a function for each coordinate halve of the two
  49.     points describing a vector that moves through two dimensional
  50.     space. Both x coordinate halves cannot be the same since the design
  51.     would simply be a collection of vertical lines. Similarly both
  52.     y coordinate halves cannot be the same.
  53.  
  54.     The functions are:
  55.  
  56.     function[0][x] = sin( 2*PI*x/NUMLINES )
  57.     function[1][x] = -sin( 2*PI*x/NUMLINES )
  58.     function[2][x] = cos( 2*PI*x/NUMLINES ) 
  59.     function[3][x] = -cos( 2*PI*x/NUMLINES ) 
  60.     function[4][x] = sin( 4*PI*x/NUMLINES )
  61.     function[5][x] = -sin( 4*PI*x/NUMLINES )
  62.     function[6][x] = cos( 4*PI*x/NUMLINES ) 
  63.     function[7][x] = -cos( 4*PI*x/NUMLINES ) 
  64.     function[8][x] = sin( 6*PI*x/NUMLINES )
  65.     function[9][x] = -sin( 6*PI*x/NUMLINES )
  66.     function[10][x] = cos( 6*PI*x/NUMLINES ) 
  67.     function[11][x] = -cos( 6*PI*x/NUMLINES ) 
  68.     function[12][x] = 2 * abs( x - (NUMLINES/2) - 1 )    *not used*
  69.  
  70.     The values of the functions were pre-computed to have the demo
  71.     run as fast as possible.  The program runs in an endless loop, it 
  72.     will terminate if the "Quit" menu item is selected or a 'Q' is typed.
  73. */
  74.  
  75. #include <qd.h>      /* quikdraw */
  76. #include <qdvars.h>    /* quickdraw globals */
  77. #include <win.h>    /* window manager */
  78. #include <menu.h>    /* menu manager */
  79. #include <event.h>    /* event manager */
  80.  
  81. #define NUMLINES    343    /* number of vectors in a design */
  82. #define NUM_FUNCTIONS    12    /* number of functions */
  83. #define VOFFSET        19    /* offset from top, drag is under menu bar */
  84. #define BORDER        2    /* surrounding blank border */
  85.                 
  86. /* get real size of screen, in case of Lisa or something new */
  87. #define HSIZE (qdvars.screenbits.bounds.a.right)
  88. #define VSIZE (qdvars.screenbits.bounds.a.bottom)
  89.  
  90. windowrecord    myrecord;    /* if you can't figure out what these are */
  91. windowptr    mywindow;    /* you'd better give up right now */
  92. menuhandle    mymenu;
  93.  
  94. int holding = 0;        /* are we currently holding? */
  95. int step = 0;            /* single step? */
  96.  
  97. int q [4][NUMLINES];        /* temp array for scaled coordinates */
  98. extern int p [NUM_FUNCTIONS][NUMLINES];
  99.     /* pre-computed points, scaled by 1024 */
  100.  
  101. main()
  102. {
  103.     int i, j, k, l, m;
  104.     long secs;
  105.     
  106.     init ();        /* do housekeeping */
  107.     showinfo ();        /* display bragging info */
  108.     getdatetime (&qdvars.randseed);    /* randomize the random() function */
  109.  
  110.     while (1) {        /* main loop, go round and round forever */
  111.         /* pick the functions */
  112.         while ((i = random() % NUM_FUNCTIONS) < 0) /* nothing */ ;
  113.         while ((j = random() % NUM_FUNCTIONS) == i || (j < 0));
  114.         while ((k = random() % NUM_FUNCTIONS) < 0);
  115.         while ((l = random() % NUM_FUNCTIONS) == k || (l < 0));
  116.  
  117.         /* scalepoints was a hack to speed up the line drawing, by
  118.            avoiding the scaling computations for each coordinate
  119.            while the lines are being drawn.  It didn't help as much
  120.            as I'd hoped, only about a second is saved, maybe less.
  121.            Apparently I'm pushing QuickDraw as fast as it will go.
  122.            The same calculations using floating point took about
  123.            45 seconds, YOW! */
  124.              
  125.         scalepoints (i, k, j, l);    /* scale to the window */
  126.         while (holding && !step)    /* loop here if holding */
  127.             checkmenu ();        /* watch events when holding */
  128.  
  129.         blankwindow (mywindow);        /* clear to black or white */
  130.         setport (mywindow);        /* point QD at my window */
  131.             /* the above statement shouldn't be necessary, but
  132.                something sneaky, like the screensaver DA, could
  133.                be lurking in the darkness and may change the
  134.                grafport out from under us.  Grrr... */
  135.         obscurecursor ();        /* get rid of the cursor */
  136.  
  137.         for (m = 0; m < NUMLINES; m++) {    /* draw the vectors */
  138.             moveto (q [0][m], q [1][m]);
  139.             lineto (q [2][m], q [3][m]);
  140.         }
  141.  
  142.         systemtask ();            /* in case of DAs */
  143.         if (!holding) sleep (6);    /* pause for ~6 secs */
  144.         step = 0;            /* only good for one shot */
  145.     }
  146. }
  147.  
  148.  
  149. /* the numbers in the array p were pre-computed using floating point
  150.    arithmetic, they were all sin or cos functions and so yielded
  151.    numbers [-1, 1].  These numbers were then scaled up by 1024 so they
  152.    could be stored as integers.  1024 was used so they could be scaled down
  153.    again with a shift-right-10 rather than a divide operation.  I use two
  154.    statements to compute each number to be sure the intermediate values
  155.    are calculated as longs, the values involved far exceed the magnitude
  156.    possible in a 16-bit int.  */
  157.      
  158. scalepoints (x1, y1, x2, y2)    int x1, y1, x2, y2;
  159. {
  160.     long  l, h, v;
  161.     int i;
  162.     
  163.     h = (HSIZE) / 2;
  164.     v = (VSIZE - VOFFSET) / 2;
  165.     for (i = 0; i < NUMLINES; i++) {
  166.         l = (((long)p [x1][i] * (h - BORDER)) >> 10) + h;
  167.         q [0][i] = (int)l;
  168.         l = (((long)p [y1][i] * (v - BORDER)) >> 10) + v;
  169.         q [1][i] = (int)l;
  170.         l = (((long)p [x2][i] * (h - BORDER)) >> 10) + h;
  171.         q [2][i] = (int)l;
  172.         l = (((long)p [y2][i] * (v - BORDER)) >> 10) + v;
  173.         q [3][i] = (int)l;
  174.         checkmenu ();    /* see if there are any events to be handled */
  175.     }
  176. }
  177.  
  178.  
  179. checkmenu ()
  180.     /* test for and handle any events, such as keyboard and mouse */
  181. {
  182.     eventrecord    theevent;
  183.     windowptr    tmpptr;
  184.     
  185.             /* loop as long as there are events in the queue */
  186.     while (getnextevent (everyevent, &theevent)) {
  187.         switch (theevent.what) {
  188.          case abortevt:        /* something is telling us to stop */
  189.              exit (0);
  190.          case keydown:        /* got a key */
  191.                     /* does this key belong to a menu? */
  192.             if (menukey ((char) (theevent.message % 256))) {
  193.                 /* yes */
  194.                 do_menu (menukey ((char) (theevent.message % 256)));
  195.             } else {
  196.                  step = 1;    /* step once (undoc feature) */    
  197.                  return;
  198.             }
  199.              break;
  200.          case mousedown:        /* mouse clicked */
  201.             if (findwindow(&theevent.where, &tmpptr) == inmenubar){
  202.                 do_menu (menuselect (&theevent.where));
  203.             } else {
  204.                 step = 1;    /* cycle once */
  205.             }
  206.             break;
  207.          case updateevt:    /* always get one of these at startup */
  208.              beginupdate (mywindow);
  209.             endupdate (mywindow);    /* only way to get rid of it */
  210.             break;
  211.          case nullevent:    /* shouldn't happen, filtered above */
  212.              return;
  213.          default:
  214.             break;        /* not interested in anything else */
  215.         }
  216.     }
  217. }
  218.  
  219. do_menu (item)        long item;    /* handle a menu selection */
  220. {
  221.     hilitemenu (1);
  222.     switch (item) {
  223.      case 0x00010001:        /* menu 1, item 1 (hold) */
  224.         toggle_hold ();
  225.          break;
  226.      case 0x00010002:        /* menu 1, item 2 (invert) */
  227.         invert ();
  228.         break;
  229.      case 0x00010003:        /* menu 1, item 3 (author info) */
  230.         showinfo ();
  231.         break;
  232.      case 0x00010004:        /* menu1, item 4 (quit) */
  233.         exit (0);
  234.     }
  235.     hilitemenu (0);
  236. }
  237.     
  238.  
  239. toggle_hold ()
  240. {
  241.     holding = !holding;        /* toggle the flag */
  242.     checkitem (mymenu, 1,  holding);
  243.         /* place or remove checkmark, depending on holding */
  244. }
  245.  
  246. invert ()
  247. {
  248.     setport (mywindow);            /* on the off chance... */
  249.     if (mywindow->pnmode == patbic) {
  250.         penmode (patcopy);            /* draw black */
  251.         textmode (srccopy);
  252.     } else {
  253.         penmode (patbic);            /* draw white */
  254.         textmode (srcbic);
  255.     }
  256.     invertrect (&mywindow->portrect);    /* flip what's onscreen */
  257. }
  258.              
  259.  
  260. init ()                    /* do initial housekeeping chores */
  261. {
  262.     managerinits ();
  263.     windowinits ();
  264.     menuinits ();
  265. }
  266.  
  267. managerinits()
  268. {
  269.        initgraf(&theport);        /* initialize qd (theport in qdvars) */
  270.     initfonts();            /* initialize font manager */
  271.     initwindows();            /* initialize window manager */
  272.     initmenus();            /* initialize menus */
  273.     initcursor();            /* set cursor to arrow */
  274.     flushevents(everyevent, 0);    /* lose any outstanding events */
  275. }
  276.  
  277. windowinits()
  278. {
  279.     rect        temprect;
  280.     
  281.     setrect(&temprect, 0, VOFFSET, HSIZE, VSIZE);
  282.     mywindow = newwindow(&myrecord, &temprect, "Stringart", 1, 0,
  283.                 (long) -1, 0, (long) 0);
  284.     setport(mywindow);        /* draw in my window */
  285.     selectwindow(mywindow);        /* make mine active */
  286.     pennormal ();            /* make sure pen has defaults */
  287.     penmode (patbic);        /* make it draw white */
  288.     textmode (srcbic);        /* make text draw white */
  289.     textfont (0);            /* use system font */
  290.     textface ((short) bold);    /* use a fancy text style */
  291. }
  292.  
  293. menuinits ()
  294. {
  295.     mymenu = newmenu (1, "StringArt");    /* allocate a menu struct */
  296.     appendmenu (mymenu,  "Hold/H");        /* load the item values */
  297.     appendmenu (mymenu, "Invert/I");
  298.     appendmenu (mymenu, "Author Info/A");
  299.     appendmenu (mymenu, "Quit/Q");
  300.     insertmenu (mymenu, 0);            /* let the OS know about it */
  301.     drawmenubar ();                /* make it show up */
  302. }
  303.  
  304. sleep (s)    int s;
  305.     /* sleep for approx s seconds, could vary from s-1 to s seconds */
  306. {
  307.     long s1, s2;
  308.  
  309.     getdatetime (&s1);        /* what time is it now? */
  310.     s1 += s;            /* looking for now + s seconds */
  311.     while (1) {
  312.         getdatetime (&s2);
  313.         if (s1 <= s2) break;    /* ok, the time has come */
  314.         checkmenu ();        /* keep an eye on events around you */
  315.     }
  316. }
  317.  
  318. blankwindow (w)        windowptr w;
  319. {
  320.     if (w->pnmode == patbic) {    /* drawing white? */
  321.         fillrect (&w->portrect, qdvars.black); /* yes, paint window black */
  322.     } else {
  323.         fillrect (&w->portrect, qdvars.white); /* no, paint it white */
  324.     }
  325. }
  326.  
  327. showinfo ()        /* display bragging info */
  328. {
  329.     static char *s [] = {
  330.         "StringArt by Ron Hitchens",
  331.         "hitchens@ut-sally.ARPA  or  ...!ihnp4!ut-sally!hitchens.UUCP",
  332.         "", "Written in MegaMax C",
  333.         "This program is public domain", "",
  334.         "While in Hold, click mouse to single step",
  335.         "To save an image, type:  SHIFT/CMD/3" ,
  336.         "To print an image, type:  SHIFT/CMD/4" };
  337.     int i, n;
  338.     static int busy = 0;
  339.     
  340.     hilitemenu (1);            /* turn on the menu */
  341.     if (busy) return;        /* info screen already up */
  342.     busy = 1;            /* to prevent recursive displays */
  343.     setport (mywindow);        /* just in case */
  344.     obscurecursor ();        /* get rid of the cursor */
  345.     blankwindow (mywindow);
  346.     n = sizeof (s) / sizeof (s [0]);    /* how many lines of text? */
  347.     textsize (24);                /* get fancy for first line */
  348.     for (i = 0; i < n; i++) {        /* display all the text */
  349.         moveto ((HSIZE / 2) - (stringwidth (s [i]) / 2),
  350.             (VSIZE / (n + 1)) + (i * (VSIZE / (n + 1))));
  351.         drawstring (s [i]);    /* draw one of the text lines */
  352.         textsize (12);        /* back to normal for the rest */
  353.     }
  354.     if (!holding) sleep (10);        /* wait a bit */
  355.     hilitemenu (0);                /* turn off the menu */
  356.     busy = 0;                /* ok, I'm finished */
  357. }
  358.